Za hranicami unit testov: Hĺbkový ponor do property-based testovania s Python knižnicou Hypothesis

Vo svete vývoja softvéru je testovanie základom kvality. Po desaťročia bol dominantnou paradigmou príkladovo-založené testovanie. Starostlivo vytvárame vstupy, definujeme očakávané výstupy a píšeme tvrdenia, aby sme overili, že náš kód sa správa podľa plánu. Tento prístup, ktorý sa nachádza v frameworkoch ako unittest a pytest, je silný a nevyhnutný. Ale čo keby som vám povedal, že existuje doplnkový prístup, ktorý dokáže odhaliť chyby, na ktoré by ste ani nepomysleli?

Vitajte vo svete property-based testovania, paradigmy, ktorá presúva zameranie z testovania konkrétnych príkladov na overovanie všeobecných vlastností vášho kódu. A v ekosystéme Pythonu je nespochybniteľným šampiónom tohto prístupu knižnica s názvom Hypothesis.

Tento komplexný sprievodca vás prevedie od úplného začiatočníka k sebavedomému praktikovi property-based testovania s Hypothesis. Preskúmame základné koncepty, ponoríme sa do praktických príkladov a naučíme sa, ako integrovať tento výkonný nástroj do vášho každodenného vývojového workflow, aby ste mohli vytvárať robustnejší, spoľahlivejší softvér odolný voči chybám.

Čo je property-based testovanie? Zmena myslenia

Aby sme pochopili Hypothesis, musíme najprv pochopiť základnú myšlienku property-based testovania. Porovnajme si ho s tradičným testovaním založeným na príkladoch, ktoré všetci poznáme.

Testovanie založené na príkladoch: Známa cesta

Predstavte si, že ste napísali vlastnú funkciu na triedenie, my_sort(). Pri testovaní založenom na príkladoch by váš myšlienkový postup bol:

• "Otestujme to s jednoduchým, usporiadaným zoznamom." -> assert my_sort([1, 2, 3]) == [1, 2, 3]
• "A čo zoznam v opačnom poradí?" -> assert my_sort([3, 2, 1]) == [1, 2, 3]
• "Čo prázdny zoznam?" -> assert my_sort([]) == []
• "Zoznam s duplikátmi?" -> assert my_sort([5, 1, 5, 2]) == [1, 2, 5, 5]
• "A zoznam s negatívnymi číslami?" -> assert my_sort([-1, -5, 0]) == [-5, -1, 0]

Toto je efektívne, ale má to zásadné obmedzenie: testujete len prípady, na ktoré dokážete myslieť. Vaše testy sú len tak dobré, ako vaša predstavivosť. Môžete prehliadnuť okrajové prípady zahŕňajúce veľmi veľké čísla, nepresnosti s pohyblivou desatinnou čiarkou, špecifické unicode znaky alebo komplexné kombinácie údajov, ktoré vedú k neočakávanému správaniu.

Property-Based testovanie: Myslenie v invariantoch

Property-based testovanie mení pravidlá hry. Namiesto poskytovania konkrétnych príkladov definujete vlastnosti alebo invarianty vašej funkcie – pravidlá, ktoré by mali platiť pre akýkoľvek platný vstup. Pre našu funkciu my_sort() by tieto vlastnosti mohli byť:

• Výstup je zoradený: Pre akýkoľvek zoznam čísel je každý prvok vo výstupnom zozname menší alebo rovný tomu, ktorý ho nasleduje.
• Výstup obsahuje rovnaké prvky ako vstup: Zoradený zoznam je iba permutáciou pôvodného zoznamu; žiadne prvky sa nepridávajú ani nestrácajú.
• Funkcia je idempotentná: Zoradenie už zoradeného zoznamu by ho nemalo zmeniť. To znamená, že my_sort(my_sort(some_list)) == my_sort(some_list).

S týmto prístupom nepíšete testovacie dáta. Píšete pravidlá. Potom necháte framework, ako je Hypothesis, generovať stovky alebo tisíce náhodných, rôznorodých a často rafinovaných vstupov, aby sa pokúsil dokázať, že vaše vlastnosti sú nesprávne. Ak nájde vstup, ktorý porušuje vlastnosť, našiel chybu.

Predstavujeme Hypothesis: Váš automatizovaný generátor testovacích dát

Hypothesis je popredná knižnica pre property-based testovanie pre Python. Berie vlastnosti, ktoré definujete, a robí ťažkú prácu generovania testovacích dát na ich spochybnenie. Nie je to len náhodný generátor dát; je to inteligentný a výkonný nástroj navrhnutý na efektívne hľadanie chýb.

Kľúčové vlastnosti Hypothesis

• Automatické generovanie testovacích prípadov: Definjete *tvar* dát, ktoré potrebujete (napríklad "zoznam celých čísel", "reťazec obsahujúci iba písmená", "dátum a čas v budúcnosti"), a Hypothesis generuje širokú škálu príkladov zodpovedajúcich tomuto tvaru.
• Inteligentné zmenšovanie (Shrinking): Toto je magická funkcia. Keď Hypothesis nájde zlyhávajúci testovací prípad (napríklad zoznam 50 komplexných čísel, ktoré spôsobí pád vašej funkcie triedenia), nehlási len tento obrovský zoznam. Inteligentne a automaticky zjednoduší vstup, aby našiel najmenší možný príklad, ktorý stále spôsobuje zlyhanie. Namiesto zoznamu s 50 prvkami môže nahlásiť, že k zlyhaniu dôjde len s [inf, nan]. To robí ladenie neuveriteľne rýchlym a efektívnym.
• Bezproblémová integrácia: Hypothesis sa dokonale integruje s populárnymi testovacími frameworkmi ako pytest a unittest. Môžete pridávať property-based testy popri vašich existujúcich testoch založených na príkladoch bez zmeny vášho workflow.
• Bohatá knižnica stratégií: Prichádza s rozsiahlou zbierkou vstavaných "stratégií" na generovanie všetkého od jednoduchých celých čísel a reťazcov po komplexné, vnorené dátové štruktúry, dátumy a časy citlivé na časovú zónu a dokonca aj polia NumPy.
• Testovanie stavu (Stateful Testing): Pre komplexnejšie systémy dokáže Hypothesis testovať sekvencie akcií na nájdenie chýb v prechodoch stavov, čo je notoricky ťažké pri testovaní založenom na príkladoch.

Začíname: Váš prvý Hypothesis test

Poďme sa pustiť do práce. Najlepší spôsob, ako pochopiť Hypothesis, je vidieť ho v akcii.

Inštalácia

Najprv si budete musieť nainštalovať Hypothesis a vami zvolený testovací runner (použijeme pytest). Je to tak jednoduché ako:

pip install pytest hypothesis

Jednoduchý príklad: Funkcia absolútnej hodnoty

Poďme si predstaviť jednoduchú funkciu, ktorá má vypočítať absolútnu hodnotu čísla. Mierne chybná implementácia môže vyzerať takto:

# v súbore s názvom `my_math.py`
def custom_abs(x):
    """Vlastná implementácia funkcie absolútnej hodnoty."""
    if x < 0:
        return -x
    return x

Teraz napíšme testovací súbor, test_my_math.py. Najprv tradičný prístup pytest:

# test_my_math.py (Založené na príkladoch)
def test_abs_positive():
    assert custom_abs(5) == 5

def test_abs_negative():
    assert custom_abs(-5) == 5

def test_abs_zero():
    assert custom_abs(0) == 0

Tieto testy prechádzajú. Naša funkcia vyzerá správne na základe týchto príkladov. Ale teraz napíšme property-based test s Hypothesis. Aká je kľúčová vlastnosť funkcie absolútnej hodnoty? Výsledok by nikdy nemal byť záporný.

# test_my_math.py (Property-based s Hypothesis)
from hypothesis import given
from hypothesis import strategies as st

from my_math import custom_abs

@given(st.integers())
def test_abs_property_is_non_negative(x):
    """Vlastnosť: Absolútna hodnota akéhokoľvek celého čísla je vždy >= 0."""
    assert custom_abs(x) >= 0

Poďme si to rozobrať:

• from hypothesis import given, strategies as st: Importujeme potrebné komponenty. given je dekorátor, ktorý premení bežnú testovaciu funkciu na property-based test. strategies je modul, kde nájdeme naše generátory dát.
• @given(st.integers()): Toto je jadro testu. Dekorátor @given hovorí Hypothesis, aby spustil túto testovaciu funkciu viackrát. Pri každom spustení vygeneruje hodnotu pomocou poskytnutej stratégie st.integers() a odovzdá ju ako argument x našej testovacej funkcii.
• assert custom_abs(x) >= 0: Toto je naša vlastnosť. Tvrdíme, že pre akékoľvek celé číslo x, ktoré Hypothesis vymyslí, musí byť výsledok našej funkcie väčší alebo rovný nule.

Keď to spustíte s pytest, pravdepodobne to prejde pre mnoho hodnôt. Hypothesis vyskúša 0, -1, 1, veľké kladné čísla, veľké záporné čísla a ďalšie. Naša jednoduchá funkcia všetky tieto prípady správne spracuje. Teraz skúsme inú stratégiu, aby sme zistili, či nájdeme slabinu.

# Testujme s číslami s pohyblivou desatinnou čiarkou
@given(st.floats())
def test_abs_floats_property(x):
    assert custom_abs(x) >= 0

Ak to spustíte, Hypothesis rýchlo nájde zlyhávajúci prípad!

Falsifying example: test_abs_floats_property(x=nan)
... 
assert custom_abs(nan) >= 0
AssertionError: assert nan >= 0

Hypothesis zistil, že naša funkcia, keď dostane float('nan') (Not a Number – Nie je číslo), vráti nan. Tvrdenie nan >= 0 je nepravdivé. Práve sme našli nenápadnú chybu, ktorú by sme pravdepodobne ani nepomysleli ručne otestovať. Mohli by sme našu funkciu opraviť, aby tento prípad spracovala, možno vyvolaním ValueError alebo vrátením špecifickej hodnoty.

Ešte lepšie, čo keby chyba bola s veľmi špecifickým číslom s pohyblivou desatinnou čiarkou? Funkcia "shrinker" v Hypothesis by vzala veľké, komplexné zlyhávajúce číslo a zredukovala ho na najjednoduchšiu možnú verziu, ktorá stále spúšťa chybu.

Sila stratégií: Tvorba vašich testovacích dát

Stratégie sú srdcom Hypothesis. Sú to recepty na generovanie dát. Knižnica obsahuje rozsiahlu škálu vstavaných stratégií a môžete ich kombinovať a prispôsobovať na generovanie prakticky akejkoľvek dátovej štruktúry, ktorú si dokážete predstaviť.

Bežné vstavané stratégie

• Číselné:
  • st.integers(min_value=0, max_value=1000): Generuje celé čísla, voliteľne v špecifickom rozsahu.
  • st.floats(min_value=0.0, max_value=1.0, allow_nan=False, allow_infinity=False): Generuje čísla s pohyblivou desatinnou čiarkou s jemným ovládaním špeciálnych hodnôt.
  • st.fractions(), st.decimals()
• Textové:
  • st.text(min_size=1, max_size=50): Generuje unicode reťazce určitej dĺžky.
  • st.text(alphabet='abcdef0123456789'): Generuje reťazce zo špecifickej znakovej sady (napr. pre hexadecimálne kódy).
  • st.characters(): Generuje jednotlivé znaky.
• Kolekcie:
  • st.lists(st.integers(), min_size=1): Generuje zoznamy, kde každý prvok je celé číslo. Všimnite si, ako odovzdávame inú stratégiu ako argument! Toto sa nazýva kompozícia.
  • st.tuples(st.text(), st.booleans()): Generuje N-tice s pevnou štruktúrou.
  • st.sets(st.integers())
  • st.dictionaries(keys=st.text(), values=st.integers()): Generuje slovníky so špecifikovanými typmi kľúčov a hodnôt.
• Časové:
  • st.dates(), st.times(), st.datetimes(), st.timedeltas(). Tieto môžu byť nastavené s ohľadom na časovú zónu.
• Rôzne:
  • st.booleans(): Generuje True alebo False.
  • st.just('constant_value'): Vždy generuje rovnakú jedinú hodnotu. Užitočné pre skladanie komplexných stratégií.
  • st.one_of(st.integers(), st.text()): Generuje hodnotu z jednej z poskytnutých stratégií.
  • st.none(): Generuje iba None.

Kombinovanie a transformovanie stratégií

Skutočná sila Hypothesis pochádza z jej schopnosti vytvárať komplexné stratégie z jednoduchších.

Používanie .map()

Metóda .map() vám umožňuje vziať hodnotu z jednej stratégie a transformovať ju na niečo iné. Toto je ideálne na vytváranie objektov vašich vlastných tried.

# Jednoduchá dátová trieda
from dataclasses import dataclass

@dataclass
class User:
    user_id: int
    username: str

# Stratégia na generovanie objektov User
user_strategy = st.builds(
    User,
    user_id=st.integers(min_value=1),
    username=st.text(min_size=3, alphabet='abcdefghijklmnopqrstuvwxyz')
)

@given(user=user_strategy)
def test_user_creation(user):
    assert isinstance(user, User)
    assert user.user_id > 0
    assert user.username.isalpha()

Používanie .filter() a assume()

Niekedy potrebujete odmietnuť určité vygenerované hodnoty. Napríklad, možno potrebujete zoznam celých čísel, kde súčet nie je nula. Mohli by ste použiť .filter():

st.lists(st.integers()).filter(lambda x: sum(x) != 0)

Avšak, používanie .filter() môže byť neefektívne. Ak je podmienka často nepravdivá, Hypothesis môže stráviť dlhý čas pokusmi o vygenerovanie platného príkladu. Lepším prístupom je často použiť assume() vo vnútri vašej testovacej funkcie:

from hypothesis import assume

@given(st.lists(st.integers()))
def test_something_with_non_zero_sum_list(numbers):
    assume(sum(numbers) != 0)
    # ... vaša testovacia logika tu ...

assume() hovorí Hypothesis: "Ak táto podmienka nie je splnená, jednoducho zahodiť tento príklad a skúsiť nový." Je to priamejší a často výkonnejší spôsob, ako obmedziť vaše testovacie dáta.

Používanie st.composite()

Pre skutočne komplexné generovanie dát, kde jedna vygenerovaná hodnota závisí od druhej, st.composite() je nástroj, ktorý potrebujete. Umožňuje vám napísať funkciu, ktorá prijíma špeciálnu funkciu draw ako argument, ktorú môžete použiť na postupné získavanie hodnôt z iných stratégií.

Klasickým príkladom je generovanie zoznamu a platného indexu do tohto zoznamu.

@st.composite
def list_and_index(draw):
    # Najprv vygenerujeme neprázdny zoznam
    my_list = draw(st.lists(st.integers(), min_size=1))
    # Potom vygenerujeme index, ktorý je zaručene platný pre daný zoznam
    index = draw(st.integers(min_value=0, max_value=len(my_list) - 1))
    return (my_list, index)

@given(data=list_and_index())
def test_list_access(data):
    my_list, index = data
    # Tento prístup je zaručene bezpečný vďaka tomu, ako sme stratégiu vytvorili
    element = my_list[index]
    assert element is not None # Jednoduché tvrdenie

Hypothesis v akcii: Scenáre z reálneho sveta

Aplikujme tieto koncepty na realistickejšie problémy, s ktorými sa softvéroví vývojári stretávajú každý deň.

Scenár 1: Testovanie funkcie serializácie dát

Predstavte si funkciu, ktorá serializuje užívateľský profil (slovník) do reťazca bezpečného pre URL a ďalšiu, ktorá ho deserializuje. Kľúčovou vlastnosťou je, že proces by mal byť dokonale reverzibilný.

import json
import base64

def serialize_profile(data: dict) -> str:
    """Serializuje slovník do URL-safe base64 reťazca."""
    json_string = json.dumps(data)
    return base64.urlsafe_b64encode(json_string.encode('utf-8')).decode('utf-8')

def deserialize_profile(encoded_str: str) -> dict:
    """Deserializuje reťazec späť do slovníka."""
    json_string = base64.urlsafe_b64decode(encoded_str.encode('utf-8')).decode('utf-8')
    return json.loads(json_string)

# Teraz k testu
# Potrebujeme stratégiu, ktorá generuje slovníky kompatibilné s JSON
json_dictionaries = st.dictionaries(
    keys=st.text(),
    values=st.recursive(st.none() | st.booleans() | st.floats(allow_nan=False) | st.text(),
                      lambda children: st.lists(children) | st.dictionaries(st.text(), children),
                      max_leaves=10)
)

@given(profile=json_dictionaries)
def test_serialization_roundtrip(profile):
    """Vlastnosť: Deserializácia zakódovaného profilu by mala vrátiť pôvodný profil."""
    encoded = serialize_profile(profile)
    decoded = deserialize_profile(encoded)
    assert profile == decoded

Tento jediný test zasiahne naše funkcie obrovskou škálou dát: prázdne slovníky, slovníky s vnorenými zoznamami, slovníky s unicode znakmi, slovníky s podivnými kľúčmi a mnoho ďalších. Je to oveľa dôkladnejšie než napísanie niekoľkých manuálnych príkladov.

Scenár 2: Testovanie algoritmu triedenia

Vráťme sa k nášmu príkladu triedenia. Takto by ste otestovali vlastnosti, ktoré sme definovali skôr.

from collections import Counter

def my_buggy_sort(numbers):
    # Zavádzame nenápadnú chybu: vynecháva duplikáty
    return sorted(list(set(numbers)))

@given(st.lists(st.integers()))
def test_sorting_properties(numbers):
    sorted_list = my_buggy_sort(numbers)

    # Vlastnosť 1: Výstup je zoradený
    for i in range(len(sorted_list) - 1):
        assert sorted_list[i] <= sorted_list[i+1]

    # Vlastnosť 2: Prvky sú rovnaké (toto nájde chybu)
    assert Counter(numbers) == Counter(sorted_list)

    # Vlastnosť 3: Funkcia je idempotentná
    assert my_buggy_sort(sorted_list) == sorted_list

Keď spustíte tento test, Hypothesis rýchlo nájde zlyhávajúci príklad pre Vlastnosť 2, napríklad numbers=[0, 0]. Naša funkcia vráti [0] a Counter([0, 0]) sa nerovná Counter([0]). Funkcia "shrinker" zabezpečí, že zlyhávajúci príklad bude čo najjednoduchší, čím sa príčina chyby stane okamžite zrejmou.

Scenár 3: Testovanie stavu (Stateful Testing)

Pre objekty s interným stavom, ktorý sa mení v priebehu času (ako databázové pripojenie, nákupný košík alebo cache), môže byť nájdenie chýb neuveriteľne ťažké. Na spustenie chyby môže byť potrebná špecifická sekvencia operácií. Hypothesis poskytuje `RuleBasedStateMachine` presne na tento účel.

Predstavte si jednoduché API pre in-memory úložisko kľúč-hodnota:

class SimpleKeyValueStore:
    def __init__(self):
        self._data = {}
    def set(self, key, value):
        self._data[key] = value
    def get(self, key):
        return self._data.get(key)
    def delete(self, key):
        if key in self._data:
            del self._data[key]
    def size(self):
        return len(self._data)

Môžeme modelovať jeho správanie a testovať ho pomocou stavového automatu:

from hypothesis.stateful import RuleBasedStateMachine, rule, Bundle

class KeyValueStoreMachine(RuleBasedStateMachine):
    def __init__(self):
        super().__init__()
        self.model = {}
        self.sut = SimpleKeyValueStore()

    # Bundle() sa používa na prenos dát medzi pravidlami
    keys = Bundle('keys')

    @rule(target=keys, key=st.text(), value=st.integers())
    def set_key(self, key, value):
        self.model[key] = value
        self.sut.set(key, value)
        return key

    @rule(key=keys)
    def delete_key(self, key):
        del self.model[key]
        self.sut.delete(key)

    @rule(key=st.text())
    def get_key(self, key):
        model_val = self.model.get(key)
        sut_val = self.sut.get(key)
        assert model_val == sut_val

    @rule()
    def check_size(self):
        assert len(self.model) == self.sut.size()

# Pre spustenie testu jednoducho odvodíte triedu z machine a unittest.TestCase
# V pytest môžete test jednoducho priradiť k triede machine
TestKeyValueStore = KeyValueStoreMachine.TestCase

Hypothesis teraz vykoná náhodné sekvencie operácií `set_key`, `delete_key`, `get_key` a `check_size`, neúnavne sa snažiac nájsť sekvenciu, ktorá spôsobí zlyhanie jedného z tvrdení. Skontroluje, či získanie vymazaného kľúča funguje správne, či je veľkosť konzistentná po viacerých nastaveniach a vymazaniach a mnoho ďalších scenárov, ktoré by ste si možno neuvedomili otestovať ručne.

Osvedčené postupy a pokročilé tipy

• Databáza príkladov: Hypothesis je inteligentná. Keď nájde chybu, uloží zlyhávajúci príklad do lokálneho adresára (.hypothesis/). Pri ďalšom spustení testov znova prehrá tento zlyhávajúci príklad, čím vám poskytne okamžitú spätnú väzbu, že chyba je stále prítomná. Po jej oprave sa príklad už neprehráva.
• Kontrola spustenia testov s @settings: Pomocou dekorátora @settings môžete riadiť mnoho aspektov spustenia testu. Môžete zvýšiť počet príkladov, nastaviť časový limit pre to, ako dlho môže bežať jeden príklad (na zachytenie nekonečných cyklov) a vypnúť určité kontroly stavu.

  @settings(max_examples=500, deadline=1000) # Spustí 500 príkladov, 1-sekundový limit
  @given(...) ...

• Reprodukcia zlyhaní: Každé spustenie Hypothesis vytlačí hodnotu seed (napr. @reproduce_failure('version', 'seed')). Ak server CI nájde chybu, ktorú nemôžete reprodukovať lokálne, môžete použiť tento dekorátor s poskytnutým seedom, aby ste prinútili Hypothesis spustiť presne rovnakú sekvenciu príkladov.
• Integrácia s CI/CD: Hypothesis sa dokonale hodí do akéhokoľvek pipeline kontinuálnej integrácie. Jeho schopnosť nájsť nejasné chyby predtým, ako sa dostanú do produkcie, z neho robí neoceniteľnú bezpečnostnú sieť.

Zmena myslenia: Myslenie vo vlastnostiach

Osvojenie si Hypothesis je viac než len učenie sa novej knižnice; ide o prijatie nového spôsobu myslenia o správnosti vášho kódu. Namiesto otázky „Aké vstupy mám testovať?“, začnete sa pýtať: „Aké sú univerzálne pravdy o tomto kóde?“

Tu sú niektoré otázky, ktoré vás môžu viesť pri identifikácii vlastností:

• Existuje reverzná operácia? (napr. serializácia/deserializácia, šifrovanie/dešifrovanie, kompresia/dekompresia). Vlastnosťou je, že vykonanie operácie a jej opaku by malo priniesť pôvodný vstup.
• Je operácia idempotentná? (napr. abs(abs(x)) == abs(x)). Použitie funkcie viackrát by malo priniesť rovnaký výsledok ako jej jednorazové použitie.
• Existuje iný, jednoduchší spôsob výpočtu rovnakého výsledku? Môžete otestovať, či vaša komplexná, optimalizovaná funkcia produkuje rovnaký výstup ako jednoduchá, zjavne správna verzia (napr. testovanie vášho sofistikovaného triedenia oproti vstavanej funkcii Pythonu sorted()).
• Čo by malo byť vždy pravdivé o výstupe? (napr. výstup funkcie `find_prime_factors` by mal obsahovať iba prvočísla a ich súčin by sa mal rovnať vstupu).
• Ako sa mení stav? (Pre stavové testovanie) Aké invarianty musia byť zachované po akejkoľvek platnej operácii? (napr. Počet položiek v nákupnom košíku nikdy nemôže byť záporný).

Záver: Nová úroveň dôvery

Property-based testovanie s Hypothesis nenahrádza testovanie založené na príkladoch. Stále potrebujete špecifické, ručne napísané testy pre kritickú obchodnú logiku a dobre pochopené požiadavky (napr. "Užívateľ z krajiny X musí vidieť cenu Y").

Hypothesis poskytuje výkonný, automatizovaný spôsob, ako preskúmať správanie vášho kódu a chrániť sa pred nepredvídanými okrajovými prípadmi. Pôsobí ako neúnavný partner, generujúci tisíce testov, ktoré sú rôznorodejšie a prefíkanejšie, než by akýkoľvek človek dokázal realisticky napísať. Definovaním základných vlastností vášho kódu vytvoríte robustnú špecifikáciu, proti ktorej môže Hypothesis testovať, čo vám dodá novú úroveň dôvery vo váš softvér.

Nabudúce, keď budete písať funkciu, venujte chvíľu premýšľaniu nad rámec príkladov. Opýtajte sa sami seba: „Aké sú pravidlá? Čo musí byť vždy pravda?“ Potom nechajte Hypothesis urobiť tú náročnú prácu pri pokusoch o ich porušenie. Budete prekvapení, čo nájde, a váš kód bude vďaka tomu lepší.